#include "SymbTable.hpp"



SymbTable::SymbTable(){
}  

SymbTable::~SymbTable(){
}

void SymbTable::afficher(){
	map<int,Categorie * >::iterator it;
	for ( it=mLines.begin() ; it != mLines.end(); it++ ){
		cout << (*it).first << "   ";
        if((*it).second->TYPE == Categorie::VARIABLE){
            Categorie * c = (*it).second;
            Variable * v =static_cast<Variable *>( c);
            v->printLine();
        }else if((*it).second->TYPE == Categorie::PROGRAM){
            Categorie * c = (*it).second;
            Program * p =static_cast<Program*>( c);
            p->printLine();
        }else if((*it).second->TYPE == Categorie::ARGUMENT){
		Categorie * c = (*it).second;
		Argument * a = static_cast<Argument*>(c);
		a->printLine();
	}else if((*it).second->TYPE == Categorie::PROCEDURE){
		Categorie * c = (*it).second;
		Procedure * proc = static_cast<Procedure*>(c);
		proc->printLine();
	}else if((*it).second->TYPE == Categorie::FONCTION){
		Categorie * c = (*it).second;
		Fonction * f = static_cast<Fonction*>(c);
		f->printLine();
	}else if((*it).second->TYPE == Categorie::TEMPORAIRE){
		Categorie * c = (*it).second;
		Temporaire * t = static_cast<Temporaire*>(c);
		t->printLine();
	}
        cout << std::endl;
	}
}


void SymbTable::ajouter(int id,string v1,string v2){
   /* vector<string> s;
    s.push_back(v1);
    s.push_back(v2);
	mSbs.insert ( pair<int,vector<string> >(id,s) );*/
     		
}
void SymbTable::ajouterVariable(int id, int type){
    Variable * v = new Variable();
    v->setType(type);
    mLines.insert(pair<int, Categorie*>(id, v));
}

void SymbTable::ajouterArgument(int id, int type){
	Argument * a = new Argument();
	a->setType(type);
	mLines.insert(pair<int, Categorie*>(id, a));
}

Categorie * SymbTable::getCategorie(int id){
	map<int,Categorie *>::iterator it;	
	it = mLines.find(id);
// putain de pute
	return (*it).second;
}

void SymbTable::ajouterProgram(int id){
    Program * p = new Program();
    mLines.insert(pair<int, Categorie*>(id, p));
}

void SymbTable::ajouterProcedure(int id, int arite , SymbTable* ts){
	Procedure * proc = new Procedure();
	proc->setArite(arite);
	proc->setTsLocale(ts);
	mLines.insert(pair<int, Categorie*>(id,proc));
}
void SymbTable::ajouterFonction(int id, int type, int arite, SymbTable* ts){
	Fonction * fonc = new Fonction();
	fonc->setTypeRetour(type);
	fonc->setArite(arite);
	fonc->setTsLocale(ts);
	mLines.insert(pair<int, Categorie*>(id,fonc));
}
void SymbTable::ajouterConstante(int id, int type, void * valeur){
	Constante * c = new Constante(type,valeur);
	mLines.insert(pair<int, Categorie*>(id,c));	
}

void SymbTable::ajouterTemporaire(int id, int type){
	
	Temporaire* temp = new Temporaire();
	temp->setType(type);
	mLines.insert(pair<int, Categorie*>(id,temp));	
}


void SymbTable::setContexteParent(string parent)
{
	this->contexteParent = parent;
}

string SymbTable::getContexteParent()
{
	return this->contexteParent;
}
void SymbTable::setContexteActuel(string actuel)
{
	this->contexteActuel = actuel;
}

string SymbTable::getContexteActuel()
{
	return this->contexteActuel;
}

int SymbTable::getIdPremier()
{
	map<int,Categorie * >::iterator it;
	it = mLines.begin();
	return (*it).first;

}

